home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / eiffel / smalleif.97 / se.t / SmallEiffel / bin_c / compile_to_c12.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-02  |  42.3 KB  |  1,761 lines
  1. /* ANSI C code generated by SmallEiffel. */
  2. /*
  3. -- SmallEiffel  -- Release (- 0.97)    --      FRANCE
  4. -- Copyright (C), 1994 - Dominique COLNET and Suzanne COLLIN 
  5. -- University Henri Poincare' - Nancy 1 - email colnet@loria.fr 
  6. -- CRIN (Centre de Recherche en Informatique de Nancy)
  7. -- FRANCE 
  8. */
  9. #include "compile_to_c.h"
  10. int rT44all_check(T44 *C){
  11. int R=0;
  12. R=((C)->_level)>=(0);
  13. return R;
  14. }
  15. void rT44set_require_check(T44 *C){
  16. C->_level=-4;
  17. }
  18. int rT3same_as(T3 C,char a1){
  19. int R=0;
  20. R=(rT3to_lower(C))==(rT3to_lower(a1));
  21. return R;
  22. }
  23. char rT3to_upper(T3 C){
  24. char R='\0';
  25. /*IF*/if ((((unsigned char)C))<(97)) {
  26. R=C;
  27. }
  28.  else if ((((unsigned char)C))>(122)) {
  29. R=C;
  30. }
  31. else {
  32. R=(((unsigned char)C))-(32);
  33. }
  34. /*FI*/return R;
  35. }
  36. int rT3is_digit(T3 C){
  37. int R=0;
  38. {int iv1=C;
  39. if ((48 <= iv1) && (iv1<= 57)) goto l462;
  40. goto l463;
  41.  l462: ;
  42. R=1;
  43. goto l461;
  44.  l463: ;
  45.  l461: ;
  46. }
  47. return R;
  48. }
  49. int rT3is_letter(T3 C){
  50. int R=0;
  51. {int iv1=C;
  52. if ((65 <= iv1) && (iv1<= 90)) goto l465;
  53. if ((97 <= iv1) && (iv1<= 122)) goto l465;
  54. goto l466;
  55.  l465: ;
  56. R=1;
  57. goto l464;
  58.  l466: ;
  59.  l464: ;
  60. }
  61. return R;
  62. }
  63. int rT3is_separator(T3 C){
  64. int R=0;
  65. {int iv1=C;
  66. if (0 == iv1) goto l468;
  67. if ((9 <= iv1) && (iv1<= 10)) goto l468;
  68. if (13 == iv1) goto l468;
  69. if (32 == iv1) goto l468;
  70. goto l469;
  71.  l468: ;
  72. R=1;
  73. goto l467;
  74.  l469: ;
  75.  l467: ;
  76. }
  77. return R;
  78. }
  79. int rT3value(T3 C){
  80. int R=0;
  81. R=(((unsigned char)C))-(48);
  82. return R;
  83. }
  84. char rT3to_lower(T3 C){
  85. char R='\0';
  86. /*IF*/if ((((unsigned char)C))<(65)) {
  87. R=C;
  88. }
  89.  else if ((((unsigned char)C))>(90)) {
  90. R=C;
  91. }
  92. else {
  93. R=(((unsigned char)C))+(32);
  94. }
  95. /*FI*/return R;
  96. }
  97. int ofBC27type_pointer=0;
  98. T0*oRBC27type_pointer;
  99. T0 * rT173type_pointer(/*C*/void){
  100. T0 * R=NULL;
  101. if (ofBC27type_pointer==0){
  102. ofBC27type_pointer=1;
  103. {T113 *n=((T113*)new(113));
  104. rT113make(n,NULL);
  105. R=(T0 *)n;}
  106. oRBC27type_pointer=R;}
  107. return oRBC27type_pointer;}
  108. int rT173static_value(T173 *C){
  109. int R=0;
  110. R=(C)->_static_value_mem;
  111. return R;
  112. }
  113. T0 * rT173to_runnable(T173 *C,T0 * a1){
  114. T0 * R=NULL;
  115. /*IF*/if (!((C)->_current_type)) {
  116. C->_current_type=a1;
  117. C->_rf=rT260get_feature((T260*)XrT58run_class(a1),(C)->_feature_name);
  118. /*IF*/if (!((C)->_rf)) {
  119. rT173error(rT173start_position(C),(T0 *)ms1134);
  120. }
  121. /*FI*/R=(T0 *)C;
  122. }
  123. else {
  124. {T173 *n=((T173*)new(173));
  125. /*(IRF3*/((n)->_feature_name)=((C)->_feature_name);
  126. /*)*/R=(T0 *)n;}
  127. R=rT173to_runnable((T173*)R,a1);
  128. }
  129. /*FI*/return R;
  130. }
  131. void rT173error(/*C*/T0 * a1,T0* a2){
  132. /*UT*/(T45*)oRBC27eh;
  133. rT45add_position(a1);
  134. rT45error((T45*)oRBC27eh,a2);
  135. }
  136. T0 * rT173add_comment(T173 *C,T0 * a1){
  137. T0 * R=NULL;
  138. /*IF*/if ((!(a1))||((rT59count((T59*)a1))==(0))) {
  139. R=(T0 *)C;
  140. }
  141. else {
  142. {T220 *n=((T220*)new(220));
  143. rT220make(n,(T0 *)C,a1);
  144. R=(T0 *)n;}}
  145. /*FI*/return R;
  146. }
  147. T0 * rT173start_position(T173 *C){
  148. T0 * R=NULL;
  149. R=XrT67start_position((C)->_feature_name);
  150. return R;
  151. }
  152. void rT173compile_to_c(T173 *C){
  153. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1188);
  154. XrT261address_of((C)->_rf);
  155. rT40put_character((T40*)oRBC27cpp,'\51');
  156. }
  157. int rT173to_integer(T173 *C){
  158. int R=0;
  159. rT173error(rT173start_position(C),(T0 *)ms175);
  160. return R;
  161. }
  162. T0 * rT173written_in(T173 *C){
  163. T0 * R=NULL;
  164. T0 * _sp=NULL;
  165. _sp=rT173start_position(C);
  166. /*IF*/if (((int)_sp)) {
  167. R=((T46*)_sp)->_base_class_name;
  168. }
  169. /*FI*/return R;
  170. }
  171. void rT173copy(T173 *C,T0 * a1){
  172. /*IF*//*AF*//*AE*/
  173. memcpy(C,a1,s[C->id]);
  174. /*FI*/}
  175. int rT173is_a(T173 *C,T0 * a1){
  176. int R=0;
  177. R=XrT58is_a(rT113run_type((T113*)/*(IRF4*/rT173type_pointer()/*)*/),XrT58run_type(XrT68result_type(a1)));
  178. /*IF*/if (!(R)) {
  179. /*UT*/(T45*)oRBC27eh;
  180. rT45add_position(rT173start_position(C));
  181. rT173error(XrT68start_position(a1),(T0 *)ms1261);
  182. }
  183. /*FI*/return R;
  184. }
  185. void rT205fatal_error(/*C*/T0* a1){
  186. rT45fatal_error((T45*)oRBC27eh,a1);
  187. }
  188. T0 * rT205first_name(T205 *C){
  189. T0 * R=NULL;
  190. R=rT128item((T128*)(C)->_names,1);
  191. return R;
  192. }
  193. T0 * rT205to_run_feature(T205 *C,T0 * a1,T0 * a2){
  194. T0 * R=NULL;
  195. {T278 *n=((T278*)new(278));
  196. rT278make(n,a1,a2,(T0 *)C);
  197. R=(T0 *)n;}
  198. return R;
  199. }
  200. void rT205error(/*C*/T0 * a1,T0* a2){
  201. /*UT*/(T45*)oRBC27eh;
  202. rT45add_position(a1);
  203. rT45error((T45*)oRBC27eh,a2);
  204. }
  205. void rT205fe_undefine(/*C*/T0 * a1,T0 * a2){
  206. /*UT*/(T45*)oRBC27eh;
  207. rT45append((T0 *)ms483);
  208. /*UT*/(T45*)oRBC27eh;
  209. rT45append(XrT67to_string(a1));
  210. /*UT*/(T45*)oRBC27eh;
  211. rT45append((T0 *)ms484);
  212. /*UT*/(T45*)oRBC27eh;
  213. rT45append(((T48*)((T50*)a2)->_base_class_name)->_to_string);
  214. rT205fatal_error((T0 *)ms485);
  215. }
  216. int rT205is_merge_with(T205 *C,T0 * a1,T0 * a2){
  217. int R=0;
  218. int _ne=0;
  219. _ne=/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/;
  220. /*IF*/if (((T0 *)(C)->_result_type)!=((T0 *)XrT62result_type(a1))) {
  221. /*IF*/if ((!((C)->_result_type))||(!(XrT62result_type(a1)))) {
  222. /*UT*/(T45*)oRBC27eh;
  223. rT45add_position(XrT62start_position(a1));
  224. rT205error(rT205start_position(C),(T0 *)ms488);
  225. }
  226. /*FI*/}
  227. /*FI*//*IF*/if (((T0 *)(C)->_arguments)!=((T0 *)XrT62arguments(a1))) {
  228. /*IF*/if ((!((C)->_arguments))||(!(XrT62arguments(a1)))) {
  229. /*UT*/(T45*)oRBC27eh;
  230. rT45add_position(XrT62start_position(a1));
  231. rT205error(rT205start_position(C),(T0 *)ms489);
  232. }
  233.  else if ((rT92count((T92*)(C)->_arguments))!=(rT92count((T92*)XrT62arguments(a1)))) {
  234. /*UT*/(T45*)oRBC27eh;
  235. rT45add_position(XrT62start_position(a1));
  236. rT205error(rT205start_position(C),(T0 *)ms490);
  237. }
  238. /*FI*/}
  239. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0)) {
  240. /*IF*/if (((int)(C)->_result_type)) {
  241. /*IF*/if (!(XrT58is_a_in((C)->_result_type,XrT62result_type(a1),a2))) {
  242. rT45error((T45*)oRBC27eh,(T0 *)ms491);
  243. }
  244. /*FI*/}
  245. /*FI*/}
  246. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0)) {
  247. /*IF*/if (((int)(C)->_arguments)) {
  248. /*IF*/if (!(rT92is_a_in((T92*)(C)->_arguments,XrT62arguments(a1),a2))) {
  249. /*UT*/(T45*)oRBC27eh;
  250. rT45add_position(XrT62start_position(a1));
  251. rT205error(rT205start_position(C),(T0 *)ms494);
  252. }
  253. /*FI*/}
  254. /*FI*/}
  255. /*FI*/R=((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0);
  256. return R;
  257. }
  258. T0 * rT205start_position(T205 *C){
  259. T0 * R=NULL;
  260. R=XrT67start_position(rT205first_name(C));
  261. return R;
  262. }
  263. void rT205collect_for(T205 *C,int a1){
  264. /*IF*/if ((a1)==(1001)) {
  265. /*IF*/if (((int)(C)->_require_assertion)) {
  266. /*IF*/if (!(rT268fast_has((T268*)oRBC62require_collector,(C)->_require_assertion))) {
  267. rT268add_last((T268*)oRBC62require_collector,(C)->_require_assertion);
  268. }
  269. /*FI*/}
  270. /*FI*/}
  271. else {
  272. /*IF*/if (((int)(C)->_ensure_assertion)) {
  273. rT157add_into((T157*)(C)->_ensure_assertion,oRBC62assertion_collector);
  274. }
  275. /*FI*/}
  276. /*FI*/}
  277. void rT205add_into(T205 *C,T0 * a1){
  278. T0 * _fn=NULL;
  279. int _i=0;
  280. C->_base_class=rT46base_class((T46*)XrT67start_position(rT128item((T128*)(C)->_names,1)));
  281. _i=1;
  282. while (!((_i)>(rT128count((T128*)(C)->_names)))) {
  283. _fn=rT128item((T128*)(C)->_names,_i);
  284. /*IF*/if (rT61has((T61*)a1,XrT67to_key(_fn))) {
  285. _fn=XrT62first_name(rT61at((T61*)a1,XrT67to_key(_fn)));
  286. /*UT*/(T45*)oRBC27eh;
  287. rT45add_position(XrT67start_position(_fn));
  288. /*UT*/(T45*)oRBC27eh;
  289. rT45add_position(XrT67start_position(rT128item((T128*)(C)->_names,_i)));
  290. rT45error((T45*)oRBC27eh,(T0 *)ms419);
  291. /*UT*/(T45*)oRBC27eh;
  292. rT45append(XrT67to_string(_fn));
  293. rT45error((T45*)oRBC27eh,(T0 *)ms38);
  294. }
  295. else {
  296. rT61put((T61*)a1,(T0 *)C,XrT67to_key(_fn));
  297. }
  298. /*FI*/_i=(_i)+(1);
  299. }
  300. }
  301. T0 * rT205try_to_undefine(T205 *C,T0 * a1,T0 * a2){
  302. T0 * R=NULL;
  303. /*IF*/if (XrT67is_frozen(a1)) {
  304. /*UT*/(T45*)oRBC27eh;
  305. rT45add_position(rT205start_position(C));
  306. rT205error(XrT67start_position(a1),(T0 *)ms482);
  307. rT205fe_undefine(a1,a2);
  308. }
  309. else {
  310. R=rT205try_to_undefine_aux(C,a1,a2);
  311. /*IF*/if (((int)R)) {
  312. XrT203set_clients(R,(C)->_clients);
  313. }
  314. else {
  315. rT205fe_undefine(a1,a2);
  316. }
  317. /*FI*/}
  318. /*FI*/return R;
  319. }
  320. T0 * rT205try_to_undefine_aux(T205 *C,T0 * a1,T0 * a2){
  321. T0 * R=NULL;
  322. R=(T0 *)C;
  323. return R;
  324. }
  325. void rT205set_header_comment(T205 *C,T0 * a1){
  326. /*IF*/if ((((int)a1))&&((rT59count((T59*)a1))>(1))) {
  327. C->_end_comment=a1;
  328. }
  329. /*FI*/}
  330. void rT205from_effective(T205 *C,T0 * a1,T0 * a2,T0 * a3,T0 * a4,T0 * a5,T0 * a6){
  331. {T128 *n=((T128*)new(128));
  332. rT128make(n,ma(129,0,1,a1));
  333. C->_names=(T0 *)n;}
  334. rT205make(C,(C)->_names,a2,a3,NULL,NULL,a4);
  335. /*(IRF3*/((C)->_ensure_assertion)=(a5);
  336. /*)*/C->_base_class=a6;
  337. }
  338. int rT205can_hide(T205 *C,T0 * a1,T0 * a2){
  339. int R=0;
  340. int _ne=0;
  341. _ne=/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/;
  342. /*IF*/if (((T0 *)(C)->_result_type)!=((T0 *)XrT62result_type(a1))) {
  343. /*IF*/if ((!((C)->_result_type))||(!(XrT62result_type(a1)))) {
  344. /*UT*/(T45*)oRBC27eh;
  345. rT45add_position(XrT62start_position(a1));
  346. rT205error(rT205start_position(C),(T0 *)ms501);
  347. }
  348. /*FI*/}
  349. /*FI*//*IF*/if (((T0 *)(C)->_arguments)!=((T0 *)XrT62arguments(a1))) {
  350. /*IF*/if ((!((C)->_arguments))||(!(XrT62arguments(a1)))) {
  351. /*UT*/(T45*)oRBC27eh;
  352. rT45add_position(XrT62start_position(a1));
  353. rT205error(rT205start_position(C),(T0 *)ms502);
  354. }
  355.  else if ((rT92count((T92*)(C)->_arguments))!=(rT92count((T92*)XrT62arguments(a1)))) {
  356. /*UT*/(T45*)oRBC27eh;
  357. rT45add_position(XrT62start_position(a1));
  358. rT205error(rT205start_position(C),(T0 *)ms503);
  359. }
  360. /*FI*/}
  361. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0)) {
  362. /*IF*/if (((int)(C)->_result_type)) {
  363. /*IF*/if (!(XrT58is_a_in((C)->_result_type,XrT62result_type(a1),a2))) {
  364. /*UT*/(T45*)oRBC27eh;
  365. rT45append((T0 *)ms504);
  366. /*UT*/(T45*)oRBC27eh;
  367. rT45append(XrT58run_time_mark(((T260*)a2)->_current_type));
  368. rT45error((T45*)oRBC27eh,(T0 *)ms505);
  369. }
  370. /*FI*/}
  371. /*FI*/}
  372. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0)) {
  373. /*IF*/if (((int)(C)->_arguments)) {
  374. /*IF*/if (!(rT92is_a_in((T92*)(C)->_arguments,XrT62arguments(a1),a2))) {
  375. /*UT*/(T45*)oRBC27eh;
  376. rT45add_position(XrT62start_position(a1));
  377. /*UT*/(T45*)oRBC27eh;
  378. rT45add_position(rT205start_position(C));
  379. /*UT*/(T45*)oRBC27eh;
  380. rT45append((T0 *)ms506);
  381. /*UT*/(T45*)oRBC27eh;
  382. rT45append(XrT58run_time_mark(((T260*)a2)->_current_type));
  383. rT45error((T45*)oRBC27eh,(T0 *)ms507);
  384. }
  385. /*FI*/}
  386. /*FI*/}
  387. /*FI*/R=((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0);
  388. return R;
  389. }
  390. T0 * rT205base_class_name(T205 *C){
  391. T0 * R=NULL;
  392. R=((T50*)(C)->_base_class)->_base_class_name;
  393. return R;
  394. }
  395. void rT205copy(T205 *C,T0 * a1){
  396. /*IF*//*AF*//*AE*/
  397. memcpy(C,a1,s[C->id]);
  398. /*FI*/}
  399. void rT205set_rescue_compound(T205 *C,T0 * a1){
  400. /*IF*/if ((((int)a1))&&(/*(IRF4*/1/*)*/)) {
  401. rT205error(rT205start_position(C),(T0 *)ms402);
  402. }
  403. /*FI*/C->_rescue_compound=a1;
  404. }
  405. void rT205make_e_feature(T205 *C,T0 * a1,T0 * a2){
  406. C->_names=a1;
  407. C->_result_type=a2;
  408. }
  409. void rT205make_routine(T205 *C,T0 * a1,T0 * a2,T0 * a3,T0 * a4,T0 * a5){
  410. rT205make_e_feature(C,a1,NULL);
  411. C->_header_comment=a4;
  412. C->_arguments=a2;
  413. C->_obsolete_mark=a3;
  414. C->_require_assertion=a5;
  415. }
  416. void rT205make(T205 *C,T0 * a1,T0 * a2,T0 * a3,T0 * a4,T0 * a5,T0 * a6){
  417. rT205make_routine(C,a1,a2,a4,a5,a6);
  418. C->_result_type=a3;
  419. }
  420. void rT204fatal_error(/*C*/T0* a1){
  421. rT45fatal_error((T45*)oRBC27eh,a1);
  422. }
  423. T0 * rT204first_name(T204 *C){
  424. T0 * R=NULL;
  425. R=rT128item((T128*)(C)->_names,1);
  426. return R;
  427. }
  428. T0 * rT204to_run_feature(T204 *C,T0 * a1,T0 * a2){
  429. T0 * R=NULL;
  430. {T278 *n=((T278*)new(278));
  431. rT278make(n,a1,a2,(T0 *)C);
  432. R=(T0 *)n;}
  433. return R;
  434. }
  435. void rT204error(/*C*/T0 * a1,T0* a2){
  436. /*UT*/(T45*)oRBC27eh;
  437. rT45add_position(a1);
  438. rT45error((T45*)oRBC27eh,a2);
  439. }
  440. void rT204fe_undefine(/*C*/T0 * a1,T0 * a2){
  441. /*UT*/(T45*)oRBC27eh;
  442. rT45append((T0 *)ms483);
  443. /*UT*/(T45*)oRBC27eh;
  444. rT45append(XrT67to_string(a1));
  445. /*UT*/(T45*)oRBC27eh;
  446. rT45append((T0 *)ms484);
  447. /*UT*/(T45*)oRBC27eh;
  448. rT45append(((T48*)((T50*)a2)->_base_class_name)->_to_string);
  449. rT204fatal_error((T0 *)ms485);
  450. }
  451. int rT204is_merge_with(T204 *C,T0 * a1,T0 * a2){
  452. int R=0;
  453. int _ne=0;
  454. _ne=/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/;
  455. /*IF*/if (((T0 *)(C)->_result_type)!=((T0 *)XrT62result_type(a1))) {
  456. /*IF*/if ((!((C)->_result_type))||(!(XrT62result_type(a1)))) {
  457. /*UT*/(T45*)oRBC27eh;
  458. rT45add_position(XrT62start_position(a1));
  459. rT204error(rT204start_position(C),(T0 *)ms488);
  460. }
  461. /*FI*/}
  462. /*FI*//*IF*/if (((T0 *)(C)->_arguments)!=((T0 *)XrT62arguments(a1))) {
  463. /*IF*/if ((!((C)->_arguments))||(!(XrT62arguments(a1)))) {
  464. /*UT*/(T45*)oRBC27eh;
  465. rT45add_position(XrT62start_position(a1));
  466. rT204error(rT204start_position(C),(T0 *)ms489);
  467. }
  468.  else if ((rT92count((T92*)(C)->_arguments))!=(rT92count((T92*)XrT62arguments(a1)))) {
  469. /*UT*/(T45*)oRBC27eh;
  470. rT45add_position(XrT62start_position(a1));
  471. rT204error(rT204start_position(C),(T0 *)ms490);
  472. }
  473. /*FI*/}
  474. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0)) {
  475. /*IF*/if (((int)(C)->_result_type)) {
  476. /*IF*/if (!(XrT58is_a_in((C)->_result_type,XrT62result_type(a1),a2))) {
  477. rT45error((T45*)oRBC27eh,(T0 *)ms491);
  478. }
  479. /*FI*/}
  480. /*FI*/}
  481. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0)) {
  482. /*IF*/if (((int)(C)->_arguments)) {
  483. /*IF*/if (!(rT92is_a_in((T92*)(C)->_arguments,XrT62arguments(a1),a2))) {
  484. /*UT*/(T45*)oRBC27eh;
  485. rT45add_position(XrT62start_position(a1));
  486. rT204error(rT204start_position(C),(T0 *)ms494);
  487. }
  488. /*FI*/}
  489. /*FI*/}
  490. /*FI*/R=((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0);
  491. return R;
  492. }
  493. T0 * rT204start_position(T204 *C){
  494. T0 * R=NULL;
  495. R=XrT67start_position(rT204first_name(C));
  496. return R;
  497. }
  498. void rT204collect_for(T204 *C,int a1){
  499. /*IF*/if ((a1)==(1001)) {
  500. /*IF*/if (((int)(C)->_require_assertion)) {
  501. /*IF*/if (!(rT268fast_has((T268*)oRBC62require_collector,(C)->_require_assertion))) {
  502. rT268add_last((T268*)oRBC62require_collector,(C)->_require_assertion);
  503. }
  504. /*FI*/}
  505. /*FI*/}
  506. else {
  507. /*IF*/if (((int)(C)->_ensure_assertion)) {
  508. rT157add_into((T157*)(C)->_ensure_assertion,oRBC62assertion_collector);
  509. }
  510. /*FI*/}
  511. /*FI*/}
  512. void rT204add_into(T204 *C,T0 * a1){
  513. T0 * _fn=NULL;
  514. int _i=0;
  515. C->_base_class=rT46base_class((T46*)XrT67start_position(rT128item((T128*)(C)->_names,1)));
  516. _i=1;
  517. while (!((_i)>(rT128count((T128*)(C)->_names)))) {
  518. _fn=rT128item((T128*)(C)->_names,_i);
  519. /*IF*/if (rT61has((T61*)a1,XrT67to_key(_fn))) {
  520. _fn=XrT62first_name(rT61at((T61*)a1,XrT67to_key(_fn)));
  521. /*UT*/(T45*)oRBC27eh;
  522. rT45add_position(XrT67start_position(_fn));
  523. /*UT*/(T45*)oRBC27eh;
  524. rT45add_position(XrT67start_position(rT128item((T128*)(C)->_names,_i)));
  525. rT45error((T45*)oRBC27eh,(T0 *)ms419);
  526. /*UT*/(T45*)oRBC27eh;
  527. rT45append(XrT67to_string(_fn));
  528. rT45error((T45*)oRBC27eh,(T0 *)ms38);
  529. }
  530. else {
  531. rT61put((T61*)a1,(T0 *)C,XrT67to_key(_fn));
  532. }
  533. /*FI*/_i=(_i)+(1);
  534. }
  535. }
  536. T0 * rT204try_to_undefine(T204 *C,T0 * a1,T0 * a2){
  537. T0 * R=NULL;
  538. /*IF*/if (XrT67is_frozen(a1)) {
  539. /*UT*/(T45*)oRBC27eh;
  540. rT45add_position(rT204start_position(C));
  541. rT204error(XrT67start_position(a1),(T0 *)ms482);
  542. rT204fe_undefine(a1,a2);
  543. }
  544. else {
  545. R=rT204try_to_undefine_aux(C,a1,a2);
  546. /*IF*/if (((int)R)) {
  547. XrT203set_clients(R,(C)->_clients);
  548. }
  549. else {
  550. rT204fe_undefine(a1,a2);
  551. }
  552. /*FI*/}
  553. /*FI*/return R;
  554. }
  555. T0 * rT204try_to_undefine_aux(T204 *C,T0 * a1,T0 * a2){
  556. T0 * R=NULL;
  557. R=(T0 *)C;
  558. return R;
  559. }
  560. void rT204set_header_comment(T204 *C,T0 * a1){
  561. /*IF*/if ((((int)a1))&&((rT59count((T59*)a1))>(1))) {
  562. C->_end_comment=a1;
  563. }
  564. /*FI*/}
  565. void rT204from_effective(T204 *C,T0 * a1,T0 * a2,T0 * a3,T0 * a4,T0 * a5){
  566. {T128 *n=((T128*)new(128));
  567. rT128make(n,ma(129,0,1,a1));
  568. C->_names=(T0 *)n;}
  569. rT204make_routine(C,(C)->_names,a2,NULL,NULL,a3);
  570. /*(IRF3*/((C)->_ensure_assertion)=(a4);
  571. /*)*/C->_base_class=a5;
  572. }
  573. int rT204can_hide(T204 *C,T0 * a1,T0 * a2){
  574. int R=0;
  575. int _ne=0;
  576. _ne=/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/;
  577. /*IF*/if (((T0 *)(C)->_result_type)!=((T0 *)XrT62result_type(a1))) {
  578. /*IF*/if ((!((C)->_result_type))||(!(XrT62result_type(a1)))) {
  579. /*UT*/(T45*)oRBC27eh;
  580. rT45add_position(XrT62start_position(a1));
  581. rT204error(rT204start_position(C),(T0 *)ms501);
  582. }
  583. /*FI*/}
  584. /*FI*//*IF*/if (((T0 *)(C)->_arguments)!=((T0 *)XrT62arguments(a1))) {
  585. /*IF*/if ((!((C)->_arguments))||(!(XrT62arguments(a1)))) {
  586. /*UT*/(T45*)oRBC27eh;
  587. rT45add_position(XrT62start_position(a1));
  588. rT204error(rT204start_position(C),(T0 *)ms502);
  589. }
  590.  else if ((rT92count((T92*)(C)->_arguments))!=(rT92count((T92*)XrT62arguments(a1)))) {
  591. /*UT*/(T45*)oRBC27eh;
  592. rT45add_position(XrT62start_position(a1));
  593. rT204error(rT204start_position(C),(T0 *)ms503);
  594. }
  595. /*FI*/}
  596. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0)) {
  597. /*IF*/if (((int)(C)->_result_type)) {
  598. /*IF*/if (!(XrT58is_a_in((C)->_result_type,XrT62result_type(a1),a2))) {
  599. /*UT*/(T45*)oRBC27eh;
  600. rT45append((T0 *)ms504);
  601. /*UT*/(T45*)oRBC27eh;
  602. rT45append(XrT58run_time_mark(((T260*)a2)->_current_type));
  603. rT45error((T45*)oRBC27eh,(T0 *)ms505);
  604. }
  605. /*FI*/}
  606. /*FI*/}
  607. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0)) {
  608. /*IF*/if (((int)(C)->_arguments)) {
  609. /*IF*/if (!(rT92is_a_in((T92*)(C)->_arguments,XrT62arguments(a1),a2))) {
  610. /*UT*/(T45*)oRBC27eh;
  611. rT45add_position(XrT62start_position(a1));
  612. /*UT*/(T45*)oRBC27eh;
  613. rT45add_position(rT204start_position(C));
  614. /*UT*/(T45*)oRBC27eh;
  615. rT45append((T0 *)ms506);
  616. /*UT*/(T45*)oRBC27eh;
  617. rT45append(XrT58run_time_mark(((T260*)a2)->_current_type));
  618. rT45error((T45*)oRBC27eh,(T0 *)ms507);
  619. }
  620. /*FI*/}
  621. /*FI*/}
  622. /*FI*/R=((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))==(0);
  623. return R;
  624. }
  625. T0 * rT204base_class_name(T204 *C){
  626. T0 * R=NULL;
  627. R=((T50*)(C)->_base_class)->_base_class_name;
  628. return R;
  629. }
  630. void rT204copy(T204 *C,T0 * a1){
  631. /*IF*//*AF*//*AE*/
  632. memcpy(C,a1,s[C->id]);
  633. /*FI*/}
  634. void rT204set_rescue_compound(T204 *C,T0 * a1){
  635. /*IF*/if ((((int)a1))&&(/*(IRF4*/1/*)*/)) {
  636. rT204error(rT204start_position(C),(T0 *)ms402);
  637. }
  638. /*FI*/C->_rescue_compound=a1;
  639. }
  640. void rT204make_e_feature(T204 *C,T0 * a1,T0 * a2){
  641. C->_names=a1;
  642. C->_result_type=a2;
  643. }
  644. void rT204make_routine(T204 *C,T0 * a1,T0 * a2,T0 * a3,T0 * a4,T0 * a5){
  645. rT204make_e_feature(C,a1,NULL);
  646. C->_header_comment=a4;
  647. C->_arguments=a2;
  648. C->_obsolete_mark=a3;
  649. C->_require_assertion=a5;
  650. }
  651. void rT204make(T204 *C,T0 * a1,T0 * a2,T0 * a3,T0 * a4,T0 * a5){
  652. rT204make_routine(C,a1,a2,a3,a4,a5);
  653. }
  654. int rT181static_value(T181 *C){
  655. int R=0;
  656. R=(C)->_static_value_mem;
  657. return R;
  658. }
  659. T0 * rT181to_runnable(T181 *C,T0 * a1){
  660. T0 * R=NULL;
  661. T0 * _rf=NULL;
  662. T0 * _rt=NULL;
  663. /*IF*/if (!((C)->_current_type)) {
  664. C->_current_type=a1;
  665. _rt=XrT58to_runnable((C)->_result_type,a1);
  666. /*IF*/if (!(_rt)) {
  667. rT181error(XrT58start_position((C)->_result_type),(T0 *)ms1144);
  668. }
  669. else {
  670. C->_result_type=_rt;
  671. R=(T0 *)C;
  672. }
  673. /*FI*//*IF*/if (rT50has_feature((T50*)rT181base_class_written(C),(C)->_to_string)) {
  674. _rf=rT260get_feature_with((T260*)XrT58run_class(a1),(C)->_to_string);
  675. /*IF*/if (((int)_rf)) {
  676. /*UT*/(T45*)oRBC27eh;
  677. rT45add_position(XrT261start_position(_rf));
  678. }
  679. /*FI*/rT181error((C)->_start_position,(T0 *)ms1145);
  680. }
  681. /*FI*/}
  682. else {
  683. R=rT181clone(C,(T0 *)C);
  684. /*(IRF3*/(((T181*)R)->_current_type)=(NULL);
  685. /*)*/R=rT181to_runnable((T181*)R,a1);
  686. }
  687. /*FI*/return R;
  688. }
  689. void rT181error(/*C*/T0 * a1,T0* a2){
  690. /*UT*/(T45*)oRBC27eh;
  691. rT45add_position(a1);
  692. rT45error((T45*)oRBC27eh,a2);
  693. }
  694. T0 * rT181add_comment(T181 *C,T0 * a1){
  695. T0 * R=NULL;
  696. /*IF*/if ((!(a1))||((rT59count((T59*)a1))==(0))) {
  697. R=(T0 *)C;
  698. }
  699. else {
  700. {T220 *n=((T220*)new(220));
  701. rT220make(n,(T0 *)C,a1);
  702. R=(T0 *)n;}}
  703. /*FI*/return R;
  704. }
  705. T0* rT181clone(T181 *C,T0* a1){
  706. T0* R=NULL;
  707. /*IF*/if (((int)a1)) {
  708. R=(T0 *)new(a1->id);
  709. AF_1
  710. XrT28copy(R,a1);
  711. AF_0
  712. }
  713. /*FI*/return R;
  714. }
  715. T0* rT181to_key(T181 *C){
  716. T0* R=NULL;
  717. R=(C)->_to_string;
  718. return R;
  719. }
  720. int rT181can_be_dropped(T181 *C){
  721. int R=0;
  722. R=XrT58is_expanded(XrT58run_type((C)->_result_type));
  723. return R;
  724. }
  725. void rT181compile_to_c(T181 *C){
  726. rT40put_character((T40*)oRBC27cpp,'\137');
  727. rT40put_string((T40*)oRBC27cpp,(C)->_to_string);
  728. }
  729. int rT181to_integer(T181 *C){
  730. int R=0;
  731. rT181error((C)->_start_position,(T0 *)ms175);
  732. return R;
  733. }
  734. T0 * rT181written_in(T181 *C){
  735. T0 * R=NULL;
  736. T0 * _sp=NULL;
  737. _sp=(C)->_start_position;
  738. /*IF*/if (((int)_sp)) {
  739. R=((T46*)_sp)->_base_class_name;
  740. }
  741. /*FI*/return R;
  742. }
  743. T0 * rT181base_class_written(T181 *C){
  744. T0 * R=NULL;
  745. R=rT48base_class((T48*)rT181written_in(C));
  746. return R;
  747. }
  748. void rT181copy(T181 *C,T0 * a1){
  749. /*IF*//*AF*//*AE*/
  750. memcpy(C,a1,s[C->id]);
  751. /*FI*/}
  752. int rT181is_a(T181 *C,T0 * a1){
  753. int R=0;
  754. R=XrT58is_a(XrT58run_type((C)->_result_type),XrT58run_type(XrT68result_type(a1)));
  755. /*IF*/if (!(R)) {
  756. /*UT*/(T45*)oRBC27eh;
  757. rT45add_position((C)->_start_position);
  758. rT181error(XrT68start_position(a1),(T0 *)ms1261);
  759. }
  760. /*FI*/return R;
  761. }
  762. void rT181make(T181 *C,T0 * a1,T0* a2,T0 * a3,int a4){
  763. C->_start_position=a1;
  764. C->_to_string=a2;
  765. C->_result_type=a3;
  766. C->_rank=a4;
  767. }
  768. int ofBC27type_string=0;
  769. T0*oRBC27type_string;
  770. T0 * rT76type_string(/*C*/void){
  771. T0 * R=NULL;
  772. if (ofBC27type_string==0){
  773. ofBC27type_string=1;
  774. {T115 *n=((T115*)new(115));
  775. rT115make(n,NULL);
  776. R=(T0 *)n;}
  777. oRBC27type_string=R;}
  778. return oRBC27type_string;}
  779. int rT76static_value(T76 *C){
  780. int R=0;
  781. R=(C)->_static_value_mem;
  782. return R;
  783. }
  784. void rT76break_line(T76 *C){
  785. /*IF*/if (!((C)->_break)) {
  786. C->_break=ma(55,2,1,(((T7*)(C)->_to_string)->_count)+(1));
  787. }
  788. else {
  789. rT55add_last((T55*)(C)->_break,(((T7*)(C)->_to_string)->_count)+(1));
  790. }
  791. /*FI*/}
  792. T0 * rT76to_runnable(T76 *C,T0 * a1){
  793. T0 * R=NULL;
  794. /*IF*/if (!((C)->_current_type)) {
  795. C->_current_type=a1;
  796. R=(T0 *)C;
  797. /*IF*/if (((C)->_id)==(0)) {
  798. C->_id=rT40add_manifest_string((T40*)oRBC27cpp,(T0 *)C);
  799. }
  800. /*FI*/rT76set_at_run_time();
  801. }
  802. else {
  803. R=rT76clone(C,(T0 *)C);
  804. /*(IRF3*/(((T76*)R)->_current_type)=(a1);
  805. /*)*/}
  806. /*FI*/return R;
  807. }
  808. void rT76add_ascii(T76 *C,char a1){
  809. rT7extend((T7*)(C)->_to_string,a1);
  810. /*IF*/if (!((C)->_ascii)) {
  811. C->_ascii=ma(55,2,1,((T7*)(C)->_to_string)->_count);
  812. }
  813. else {
  814. rT55add_last((T55*)(C)->_ascii,((T7*)(C)->_to_string)->_count);
  815. }
  816. /*FI*/}
  817. void rT76add(T76 *C,char a1){
  818. rT7extend((T7*)(C)->_to_string,a1);
  819. }
  820. void rT76error(/*C*/T0 * a1,T0* a2){
  821. /*UT*/(T45*)oRBC27eh;
  822. rT45add_position(a1);
  823. rT45error((T45*)oRBC27eh,a2);
  824. }
  825. T0 * rT76add_comment(T76 *C,T0 * a1){
  826. T0 * R=NULL;
  827. /*IF*/if ((!(a1))||((rT59count((T59*)a1))==(0))) {
  828. R=(T0 *)C;
  829. }
  830. else {
  831. {T220 *n=((T220*)new(220));
  832. rT220make(n,(T0 *)C,a1);
  833. R=(T0 *)n;}}
  834. /*FI*/return R;
  835. }
  836. int ofBC76set_at_run_time=0;
  837. void rT76set_at_run_time(/*C*/void){
  838. if (ofBC76set_at_run_time==0){
  839. ofBC76set_at_run_time=1;
  840. rT260set_at_run_time((T260*)XrT58run_class(rT115run_type((T115*)/*(IRF4*/rT76type_string()/*)*/)));
  841. }
  842. }
  843. T0* rT76clone(T76 *C,T0* a1){
  844. T0* R=NULL;
  845. /*IF*/if (((int)a1)) {
  846. R=(T0 *)new(a1->id);
  847. AF_1
  848. XrT28copy(R,a1);
  849. AF_0
  850. }
  851. /*FI*/return R;
  852. }
  853. void rT76compile_to_c(T76 *C){
  854. rT40manifest_string_mapping_c((T40*)oRBC27cpp,(C)->_id);
  855. }
  856. void rT76add_percent(T76 *C,char a1){
  857. rT7extend((T7*)(C)->_to_string,a1);
  858. /*IF*/if (!((C)->_percent)) {
  859. C->_percent=ma(55,2,1,((T7*)(C)->_to_string)->_count);
  860. }
  861. else {
  862. rT55add_last((T55*)(C)->_percent,((T7*)(C)->_to_string)->_count);
  863. }
  864. /*FI*/}
  865. int rT76to_integer(T76 *C){
  866. int R=0;
  867. rT76error((C)->_start_position,(T0 *)ms175);
  868. return R;
  869. }
  870. T0 * rT76written_in(T76 *C){
  871. T0 * R=NULL;
  872. T0 * _sp=NULL;
  873. _sp=(C)->_start_position;
  874. /*IF*/if (((int)_sp)) {
  875. R=((T46*)_sp)->_base_class_name;
  876. }
  877. /*FI*/return R;
  878. }
  879. void rT76copy(T76 *C,T0 * a1){
  880. /*IF*//*AF*//*AE*/
  881. memcpy(C,a1,s[C->id]);
  882. /*FI*/}
  883. int rT76is_a(T76 *C,T0 * a1){
  884. int R=0;
  885. R=XrT58is_a(rT115run_type((T115*)/*(IRF4*/rT76type_string()/*)*/),XrT58run_type(XrT68result_type(a1)));
  886. /*IF*/if (!(R)) {
  887. /*UT*/(T45*)oRBC27eh;
  888. rT45add_position((C)->_start_position);
  889. rT76error(XrT68start_position(a1),(T0 *)ms1261);
  890. }
  891. /*FI*/return R;
  892. }
  893. void rT76make(T76 *C,T0 * a1){
  894. C->_start_position=a1;
  895. {T7 *n=((T7*)new(7));
  896. rT7make(n,0);
  897. C->_to_string=(T0 *)n;}
  898. }
  899. void rT123error(/*C*/T0 * a1,T0* a2){
  900. /*UT*/(T45*)oRBC27eh;
  901. rT45add_position(a1);
  902. rT45error((T45*)oRBC27eh,a2);
  903. }
  904. T0 * rT123merge_with(T123 *C,T0 * a1,T0 * a2,T0 * a3){
  905. T0 * R=NULL;
  906. /*IF*/if (((T0 *)C)==((T0 *)a1)) {
  907. R=(T0 *)C;
  908. }
  909.  else if ((rT123is_omitted(C))||(rT123gives_permission_to_any(C))) {
  910. R=(T0 *)C;
  911. }
  912.  else if ((rT123is_omitted((T123*)a1))||(rT123gives_permission_to_any((T123*)a1))) {
  913. R=a1;
  914. }
  915. else {
  916. /*UT*/(T45*)oRBC27eh;
  917. rT45add_position((C)->_start_position);
  918. rT123error(((T123*)a1)->_start_position,(T0 *)ms1127);
  919. /*UT*/(T45*)oRBC27eh;
  920. rT45add_position(XrT67start_position(a2));
  921. rT123error(XrT62start_position(a3),(T0 *)ms1128);
  922. }
  923. /*FI*/return R;
  924. }
  925. T0 * rT123class_with(/*C*/T0* a1){
  926. T0 * R=NULL;
  927. R=(/*UT*/(T52*)oRBC27small_eiffel,
  928. rT52get_class(a1));
  929. return R;
  930. }
  931. int rT123is_omitted(T123 *C){
  932. int R=0;
  933. R=!((C)->_start_position);
  934. return R;
  935. }
  936. void rT123copy(T123 *C,T0 * a1){
  937. /*IF*//*AF*//*AE*/
  938. memcpy(C,a1,s[C->id]);
  939. /*FI*/}
  940. int rT123gives_permission_to_any(T123 *C){
  941. int R=0;
  942. R=rT123gives_permission_to(C,((T50*)/*(IRF4*/rT123class_with((T0 *)ms183)/*)*/)->_base_class_name);
  943. return R;
  944. }
  945. int rT123gives_permission_to(T123 *C,T0 * a1){
  946. int R=0;
  947. /*IF*/if (rT123is_omitted(C)) {
  948. R=1;
  949. }
  950.  else if (!((C)->_list)) {
  951. }
  952. else {
  953. R=rT126gives_permission_to((T126*)(C)->_list,a1);
  954. }
  955. /*FI*//*IF*/if (!(R)) {
  956. /*UT*/(T45*)oRBC27eh;
  957. rT45add_position((C)->_start_position);
  958. /*UT*/(T45*)oRBC27eh;
  959. rT45append(((T48*)a1)->_to_string);
  960. /*UT*/(T45*)oRBC27eh;
  961. rT45append((T0 *)ms470);
  962. }
  963. /*FI*/return R;
  964. }
  965. void rT123make(T123 *C,T0 * a1,T0* a2){
  966. C->_start_position=a1;
  967. /*IF*/if (((int)a2)) {
  968. {T126 *n=((T126*)new(126));
  969. rT126make(n,a2);
  970. C->_list=(T0 *)n;}
  971. }
  972. /*FI*/}
  973. T0 * rT139name(T139 *C,int a1){
  974. T0 * R=NULL;
  975. R=((T94*)rT96item((T96*)(C)->_flat_list,a1))->_name;
  976. return R;
  977. }
  978. T0 * rT139type(T139 *C,int a1){
  979. T0 * R=NULL;
  980. /*IF*/if (((int)(C)->_run_types)) {
  981. R=rT106item((T106*)(C)->_run_types,a1);
  982. }
  983. else {
  984. R=((T94*)rT96item((T96*)(C)->_flat_list,a1))->_type;
  985. }
  986. /*FI*/return R;
  987. }
  988. T0*oRBC139c2c_mem;
  989. T0 * rT139to_runnable(T139 *C,T0 * a1){
  990. T0 * R=NULL;
  991. T0 * _t2=NULL;
  992. T0 * _t1=NULL;
  993. int _i=0;
  994. /*IF*/if (!((C)->_run_types)) {
  995. R=(T0 *)C;
  996. {T106 *n=((T106*)new(106));
  997. rT106make(n,1,((T96*)(C)->_flat_list)->_upper);
  998. C->_run_types=(T0 *)n;}
  999. _i=1;
  1000. while (!((_i)>(((T106*)(C)->_run_types)->_upper))) {
  1001. _t1=((T94*)rT96item((T96*)(C)->_flat_list,_i))->_type;
  1002. _t2=XrT58to_runnable(_t1,a1);
  1003. /*IF*/if (!(_t2)) {
  1004. rT139error(XrT58start_position(_t1),(T0 *)ms514);
  1005. }
  1006. else {
  1007. rT106put((T106*)(C)->_run_types,_t2,_i);
  1008. }
  1009. /*FI*/_i=(_i)+(1);
  1010. }
  1011. }
  1012. else {
  1013. R=rT139to_runnable((T139*)rT139clone(C,(T0 *)C),a1);
  1014. }
  1015. /*FI*/return R;
  1016. }
  1017. int rT139count(T139 *C){
  1018. int R=0;
  1019. R=((T96*)(C)->_flat_list)->_upper;
  1020. return R;
  1021. }
  1022. void rT139error(/*C*/T0 * a1,T0* a2){
  1023. /*UT*/(T45*)oRBC27eh;
  1024. rT45add_position(a1);
  1025. rT45error((T45*)oRBC27eh,a2);
  1026. }
  1027. int rT139rank_of(T139 *C,T0 * a1){
  1028. int R=0;
  1029. T0* _ns=NULL;
  1030. _ns=XrT49to_string(a1);
  1031. R=rT139count(C);
  1032. while (!(((R)==(0))||(rT7is_equal((T7*)_ns,XrT49to_string(rT139name(C,R)))))) {
  1033. R=(R)-(1);
  1034. }
  1035. return R;
  1036. }
  1037. T0* rT139clone(T139 *C,T0* a1){
  1038. T0* R=NULL;
  1039. /*IF*/if (((int)a1)) {
  1040. R=(T0 *)new(a1->id);
  1041. AF_1
  1042. XrT28copy(R,a1);
  1043. AF_0
  1044. }
  1045. /*FI*/return R;
  1046. }
  1047. void rT139compile_to_c(T139 *C){
  1048. T0 * _t=NULL;
  1049. int _i=0;
  1050. _i=rT139count(C);
  1051. while (!((_i)==(0))) {
  1052. _t=XrT58run_type(rT139type(C,_i));
  1053. /*(IRF3*/(((T7*)oRBC139c2c_mem)->_count)=(0);
  1054. /*)*/XrT58c_type_in(_t,oRBC139c2c_mem);
  1055. rT7append((T7*)oRBC139c2c_mem,(T0 *)ms1368);
  1056. rT7append((T7*)oRBC139c2c_mem,XrT49to_string(rT139name(C,_i)));
  1057. rT7extend((T7*)oRBC139c2c_mem,'\75');
  1058. rT40put_string((T40*)oRBC27cpp,oRBC139c2c_mem);
  1059. XrT58c_initialize(_t);
  1060. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1369);
  1061. _i=(_i)-(1);
  1062. }
  1063. }
  1064. void rT139copy(T139 *C,T0 * a1){
  1065. C->_start_position=((T139*)a1)->_start_position;
  1066. C->_list=((T139*)a1)->_list;
  1067. C->_flat_list=((T139*)a1)->_flat_list;
  1068. }
  1069. void rT139initialize_expanded(T139 *C){
  1070. T0 * _rf=NULL;
  1071. T0 * _t=NULL;
  1072. int _i=0;
  1073. _i=rT139count(C);
  1074. while (!((_i)==(0))) {
  1075. _t=XrT58run_type(rT139type(C,_i));
  1076. /*IF*/if (XrT58is_expanded(_t)) {
  1077. /*IF*/if (!(XrT58fast_mapping_c(_t))) {
  1078. _rf=rT50expanded_initializer((T50*)XrT58base_class(_t),_t);
  1079. /*IF*/if (((int)_rf)) {
  1080. rT40push_local_expanded((T40*)oRBC27cpp,XrT49to_string(rT139name(C,_i)));
  1081. XrT261mapping_c(_rf);
  1082. rT40pop((T40*)oRBC27cpp);
  1083. /*IF*/if (rT40call_invariant_start((T40*)oRBC27cpp,XrT261current_type(_rf))) {
  1084. rT40put_character((T40*)oRBC27cpp,'\46');
  1085. rT40put_local_name((T40*)oRBC27cpp,XrT49to_string(rT139name(C,_i)));
  1086. rT40call_invariant_end((T40*)oRBC27cpp);
  1087. rT40put_semicolon((T40*)oRBC27cpp);
  1088. }
  1089. /*FI*/}
  1090. /*FI*/}
  1091. /*FI*/}
  1092. /*FI*/_i=(_i)-(1);
  1093. }
  1094. }
  1095. void rT139make(T139 *C,T0 * a1,T0* a2){
  1096. int _actual_count=0;
  1097. int _ifl=0;
  1098. int _il=0;
  1099. C->_start_position=a1;
  1100. C->_list=a2;
  1101. _il=1;
  1102. while (!((_il)>(XrT143upper((C)->_list)))) {
  1103. _actual_count=(_actual_count)+(XrT95count(XrT143item((C)->_list,_il)));
  1104. _il=(_il)+(1);
  1105. }
  1106. {T96 *n=((T96*)new(96));
  1107. rT96make(n,1,_actual_count);
  1108. C->_flat_list=(T0 *)n;}
  1109. _ifl=1;
  1110. _il=1;
  1111. while (!((_il)>(XrT143upper((C)->_list)))) {
  1112. _ifl=XrT95put_into(XrT143item((C)->_list,_il),(C)->_flat_list,_ifl);
  1113. _il=(_il)+(1);
  1114. }
  1115. }
  1116. T0 * rT160type_any(/*C*/void){
  1117. T0 * R=NULL;
  1118. if (ofBC27type_any==0){
  1119. ofBC27type_any=1;
  1120. {T87 *n=((T87*)new(87));
  1121. rT87make(n,NULL);
  1122. R=(T0 *)n;}
  1123. oRBC27type_any=R;}
  1124. return oRBC27type_any;}
  1125. int rT160static_value(T160 *C){
  1126. int R=0;
  1127. R=(C)->_static_value_mem;
  1128. return R;
  1129. }
  1130. T0 * rT160to_runnable(T160 *C,T0 * a1){
  1131. T0 * R=NULL;
  1132. T0 * _t=NULL;
  1133. T0 * _e=NULL;
  1134. int _i=0;
  1135. /*IF*/if (!((C)->_current_type)) {
  1136. C->_current_type=a1;
  1137. /*IF*/if (!((C)->_list)) {
  1138. _t=rT160type_any();
  1139. }
  1140. else {
  1141. _i=1;
  1142. while (!((_i)>(XrT81upper((C)->_list)))) {
  1143. _e=XrT68to_runnable(XrT81item((C)->_list,_i),a1);
  1144. /*IF*/if (!(_e)) {
  1145. /*UT*/(T45*)oRBC27eh;
  1146. rT45add_position((C)->_start_position);
  1147. rT160error(XrT68start_position(XrT81item((C)->_list,_i)),(T0 *)ms1117);
  1148. _i=(XrT81upper((C)->_list))+(1);
  1149. }
  1150. else {
  1151. XrT81put((C)->_list,_e,_i);
  1152. /*IF*/if (!(_t)) {
  1153. _t=XrT68result_type(_e);
  1154. }
  1155. else {
  1156. _t=XrT58smallest_ancestor(_t,XrT68result_type(_e));
  1157. }
  1158. /*FI*/_i=(_i)+(1);
  1159. }
  1160. /*FI*/}
  1161. }
  1162. /*FI*//*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  1163. {T105 *n=((T105*)new(105));
  1164. rT105make(n,NULL,_t);
  1165. C->_result_type=(T0 *)n;}
  1166. C->_result_type=rT105to_runnable((T105*)(C)->_result_type,(C)->_current_type);
  1167. rT260set_at_run_time((T260*)rT105run_class((T105*)(C)->_result_type));
  1168. R=(T0 *)C;
  1169. }
  1170. /*FI*/}
  1171. else {
  1172. {T160 *n=((T160*)new(160));
  1173. rT160make(n,(C)->_start_position,rT160clone(C,(C)->_list));
  1174. R=(T0 *)n;}
  1175. R=rT160to_runnable((T160*)R,a1);
  1176. }
  1177. /*FI*/return R;
  1178. }
  1179. void rT160error(/*C*/T0 * a1,T0* a2){
  1180. /*UT*/(T45*)oRBC27eh;
  1181. rT45add_position(a1);
  1182. rT45error((T45*)oRBC27eh,a2);
  1183. }
  1184. T0 * rT160add_comment(T160 *C,T0 * a1){
  1185. T0 * R=NULL;
  1186. /*IF*/if ((!(a1))||((rT59count((T59*)a1))==(0))) {
  1187. R=(T0 *)C;
  1188. }
  1189. else {
  1190. {T220 *n=((T220*)new(220));
  1191. rT220make(n,(T0 *)C,a1);
  1192. R=(T0 *)n;}}
  1193. /*FI*/return R;
  1194. }
  1195. int rT160use_current(T160 *C){
  1196. int R=0;
  1197. int _i=0;
  1198. /*IF*/if (((int)(C)->_list)) {
  1199. _i=1;
  1200. while (!(((_i)>(XrT81upper((C)->_list)))||(R))) {
  1201. R=XrT68use_current(XrT81item((C)->_list,_i));
  1202. _i=(_i)+(1);
  1203. }
  1204. }
  1205. /*FI*/return R;
  1206. }
  1207. T0* rT160clone(T160 *C,T0* a1){
  1208. T0* R=NULL;
  1209. /*IF*/if (((int)a1)) {
  1210. R=(T0 *)new(a1->id);
  1211. AF_1
  1212. XrT28copy(R,a1);
  1213. AF_0
  1214. }
  1215. /*FI*/return R;
  1216. }
  1217. void rT160compile_to_c_old(T160 *C){
  1218. int _i=0;
  1219. /*IF*/if (((int)(C)->_list)) {
  1220. _i=1;
  1221. while (!((_i)>(XrT81upper((C)->_list)))) {
  1222. XrT68compile_to_c_old(XrT81item((C)->_list,_i));
  1223. _i=(_i)+(1);
  1224. }
  1225. }
  1226. /*FI*/}
  1227. void rT160compile_to_c(T160 *C){
  1228. int _adr=0;
  1229. T0 * _elt_type=NULL;
  1230. int _i=0;
  1231. _elt_type=XrT58run_type(rT106first((T106*)((T105*)(C)->_result_type)->_generic_list));
  1232. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1160);
  1233. rT40put_integer((T40*)oRBC27cpp,rT105id((T105*)(C)->_result_type));
  1234. rT40put_character((T40*)oRBC27cpp,'\54');
  1235. /*IF*/if (XrT58is_reference(_elt_type)) {
  1236. rT40put_string((T40*)oRBC27cpp,(T0 *)ms1161);
  1237. }
  1238. else {
  1239. rT40put_integer((T40*)oRBC27cpp,XrT58id(_elt_type));
  1240. rT40put_character((T40*)oRBC27cpp,'\54');
  1241. }
  1242. /*FI*//*IF*/if (!((C)->_list)) {
  1243. rT40put_character((T40*)oRBC27cpp,'0');
  1244. }
  1245. else {
  1246. _adr=(XrT58is_expanded(_elt_type))&&(!(XrT58fast_mapping_c(_elt_type)));
  1247. rT40put_integer((T40*)oRBC27cpp,XrT81upper((C)->_list));
  1248. _i=1;
  1249. while (!((_i)>(XrT81upper((C)->_list)))) {
  1250. rT40put_character((T40*)oRBC27cpp,'\54');
  1251. /*IF*/if (_adr) {
  1252. rT40put_character((T40*)oRBC27cpp,'\46');
  1253. }
  1254. /*FI*/XrT68compile_to_c(XrT81item((C)->_list,_i));
  1255. _i=(_i)+(1);
  1256. }
  1257. }
  1258. /*FI*/rT40put_character((T40*)oRBC27cpp,'\51');
  1259. }
  1260. int rT160to_integer(T160 *C){
  1261. int R=0;
  1262. rT160error((C)->_start_position,(T0 *)ms175);
  1263. return R;
  1264. }
  1265. T0 * rT160written_in(T160 *C){
  1266. T0 * R=NULL;
  1267. T0 * _sp=NULL;
  1268. _sp=(C)->_start_position;
  1269. /*IF*/if (((int)_sp)) {
  1270. R=((T46*)_sp)->_base_class_name;
  1271. }
  1272. /*FI*/return R;
  1273. }
  1274. void rT160copy(T160 *C,T0 * a1){
  1275. /*IF*//*AF*//*AE*/
  1276. memcpy(C,a1,s[C->id]);
  1277. /*FI*/}
  1278. int rT160is_a(T160 *C,T0 * a1){
  1279. int R=0;
  1280. R=rT105is_a((T105*)((T105*)(C)->_result_type)->_run_type,XrT58run_type(XrT68result_type(a1)));
  1281. /*IF*/if (!(R)) {
  1282. /*UT*/(T45*)oRBC27eh;
  1283. rT45add_position((C)->_start_position);
  1284. rT160error(XrT68start_position(a1),(T0 *)ms1261);
  1285. }
  1286. /*FI*/return R;
  1287. }
  1288. int rT160is_pre_computable(T160 *C){
  1289. int R=0;
  1290. T0 * _e=NULL;
  1291. int _i=0;
  1292. /*IF*/if (!((C)->_list)) {
  1293. R=1;
  1294. }
  1295.  else if (XrT58is_string(rT106first((T106*)((T105*)(C)->_result_type)->_generic_list))) {
  1296. R=1;
  1297. _i=XrT81upper((C)->_list);
  1298. while (!((!(R))||((_i)==(0)))) {
  1299. _e=XrT81item((C)->_list,_i);
  1300. R=XrT68is_pre_computable(_e);
  1301. _i=(_i)-(1);
  1302. }
  1303. }
  1304. /*FI*/return R;
  1305. }
  1306. void rT160make(T160 *C,T0 * a1,T0* a2){
  1307. C->_start_position=a1;
  1308. C->_list=a2;
  1309. }
  1310. void rT264forth(T264 *C){
  1311. int _i=0;
  1312. /*IF*/if ((rT55item((T55*)(C)->_chain,(C)->_item_mem_j))!=(0)) {
  1313. C->_item_mem_j=rT55item((T55*)(C)->_chain,(C)->_item_mem_j);
  1314. }
  1315. else {
  1316. _i=((C)->_item_mem_i)+(1);
  1317. while (!((rT55item((T55*)(C)->_buckets,_i))!=(0))) {
  1318. _i=(_i)+(1);
  1319. }
  1320. C->_item_mem_i=_i;
  1321. C->_item_mem_j=rT55item((T55*)(C)->_buckets,_i);
  1322. }
  1323. /*FI*/C->_item_mem=((C)->_item_mem)+(1);
  1324. }
  1325. void rT264first(T264 *C){
  1326. int _i=0;
  1327. _i=0;
  1328. while (!((rT55item((T55*)(C)->_buckets,_i))!=(0))) {
  1329. _i=(_i)+(1);
  1330. }
  1331. C->_item_mem_i=_i;
  1332. C->_item_mem_j=rT55item((T55*)(C)->_buckets,_i);
  1333. C->_item_mem=1;
  1334. }
  1335. void rT264resize(T264 *C,int a1){
  1336. int _p=0;
  1337. int _n=0;
  1338. int _i=0;
  1339. T0* _new_buc=NULL;
  1340. int _hash=0;
  1341. {T55 *n=((T55*)new(55));
  1342. rT55make(n,0,(a1)-(1));
  1343. _new_buc=(T0 *)n;}
  1344. _i=0;
  1345. while (!((_i)>=((C)->_modulus))) {
  1346. _n=rT55item((T55*)(C)->_buckets,_i);
  1347. while (!((_n)==(0))) {
  1348. _p=rT55item((T55*)(C)->_chain,_n);
  1349. _hash=(rT7hash_code((T7*)rT41item((T41*)(C)->_keys,_n)))%(a1);
  1350. rT55put((T55*)(C)->_chain,rT55item((T55*)_new_buc,_hash),_n);
  1351. rT55put((T55*)_new_buc,_n,_hash);
  1352. _n=_p;
  1353. }
  1354. _i=(_i)+(1);
  1355. }
  1356. C->_buckets=_new_buc;
  1357. C->_modulus=a1;
  1358. C->_item_mem=0;
  1359. }
  1360. T0 * rT264item(T264 *C,int a1){
  1361. T0 * R=NULL;
  1362. /*IF*/if (((C)->_item_mem)==(0)) {
  1363. rT264first(C);
  1364. while (!((a1)==((C)->_item_mem))) {
  1365. rT264forth(C);
  1366. }
  1367. R=XrT265item((C)->_store,(C)->_item_mem_j);
  1368. }
  1369.  else if (((C)->_item_mem)<=(a1)) {
  1370. while (!((a1)==((C)->_item_mem))) {
  1371. rT264forth(C);
  1372. }
  1373. R=XrT265item((C)->_store,(C)->_item_mem_j);
  1374. }
  1375. else {
  1376. C->_item_mem=0;
  1377. R=rT264item(C,a1);
  1378. }
  1379. /*FI*/return R;
  1380. }
  1381. T0* rT264clone(T264 *C,T0* a1){
  1382. T0* R=NULL;
  1383. /*IF*/if (((int)a1)) {
  1384. R=(T0 *)new(a1->id);
  1385. AF_1
  1386. XrT28copy(R,a1);
  1387. AF_0
  1388. }
  1389. /*FI*/return R;
  1390. }
  1391. T0 * rT264at(T264 *C,T0* a1){
  1392. T0 * R=NULL;
  1393. int _foo=0;
  1394. _foo=rT264has(C,a1);
  1395. R=XrT265item((C)->_store,(C)->_has_mem);
  1396. return R;
  1397. }
  1398. void rT264put(T264 *C,T0 * a1,T0* a2){
  1399. int _hash=0;
  1400. _hash=(rT7hash_code((T7*)a2))%((C)->_modulus);
  1401. /*IF*/if ((((C)->_has_mem)==(0))||(!(rT7is_equal((T7*)a2,rT41item((T41*)(C)->_keys,(C)->_has_mem))))) {
  1402. C->_has_mem=rT55item((T55*)(C)->_buckets,_hash);
  1403. while (!((((C)->_has_mem)==(0))||(rT7is_equal((T7*)a2,rT41item((T41*)(C)->_keys,(C)->_has_mem))))) {
  1404. C->_has_mem=rT55item((T55*)(C)->_chain,(C)->_has_mem);
  1405. }
  1406. /*IF*/if (((C)->_has_mem)==(0)) {
  1407. /*IF*/if (((C)->_count)>=(XrT265count((C)->_store))) {
  1408. rT264expand(C);
  1409. }
  1410. /*FI*/rT41put((T41*)(C)->_keys,a2,(C)->_free);
  1411. XrT265put((C)->_store,a1,(C)->_free);
  1412. C->_has_mem=(C)->_free;
  1413. C->_free=rT55item((T55*)(C)->_chain,(C)->_free);
  1414. rT55put((T55*)(C)->_chain,rT55item((T55*)(C)->_buckets,_hash),(C)->_has_mem);
  1415. rT55put((T55*)(C)->_buckets,(C)->_has_mem,_hash);
  1416. C->_count=((C)->_count)+(1);
  1417. /*IF*/if (((C)->_count)>(((C)->_modulus)*(2))) {
  1418. rT264resize(C,(2)*((C)->_modulus));
  1419. }
  1420. /*FI*/}
  1421. /*FI*/}
  1422. else {
  1423. XrT265put((C)->_store,a1,(C)->_has_mem);
  1424. }
  1425. /*FI*/C->_item_mem=0;
  1426. }
  1427. void rT264standard_copy(T264 *C,T0 * a1){
  1428. memcpy(C,a1,s[a1->id]);
  1429. }
  1430. void rT264copy(T264 *C,T0 * a1){
  1431. rT264standard_copy(C,a1);
  1432. C->_keys=rT264clone(C,((T264*)a1)->_keys);
  1433. C->_store=rT264clone(C,((T264*)a1)->_store);
  1434. C->_buckets=rT264clone(C,((T264*)a1)->_buckets);
  1435. C->_chain=rT264clone(C,((T264*)a1)->_chain);
  1436. }
  1437. int rT264has(T264 *C,T0* a1){
  1438. int R=0;
  1439. /*IF*/if ((((C)->_has_mem)==(0))||(!(rT7is_equal((T7*)a1,rT41item((T41*)(C)->_keys,(C)->_has_mem))))) {
  1440. C->_has_mem=rT55item((T55*)(C)->_buckets,(rT7hash_code((T7*)a1))%((C)->_modulus));
  1441. while (!((((C)->_has_mem)==(0))||(rT7is_equal((T7*)a1,rT41item((T41*)(C)->_keys,(C)->_has_mem))))) {
  1442. C->_has_mem=rT55item((T55*)(C)->_chain,(C)->_has_mem);
  1443. }
  1444. }
  1445. /*FI*/R=((C)->_has_mem)!=(0);
  1446. return R;
  1447. }
  1448. void rT264expand(T264 *C){
  1449. int _old_size=0;
  1450. int _i=0;
  1451. C->_item_mem=0;
  1452. _old_size=XrT265count((C)->_store);
  1453. rT55resize((T55*)(C)->_chain,1,(2)*(_old_size));
  1454. rT41resize((T41*)(C)->_keys,1,(2)*(_old_size));
  1455. XrT265resize((C)->_store,1,(2)*(_old_size));
  1456. _i=(_old_size)+(1);
  1457. while (!((_i)==(rT55count((T55*)(C)->_chain)))) {
  1458. rT55put((T55*)(C)->_chain,(_i)+(1),_i);
  1459. _i=(_i)+(1);
  1460. }
  1461. rT55put((T55*)(C)->_chain,(C)->_free,_i);
  1462. C->_free=(_old_size)+(1);
  1463. }
  1464. void rT264make(T264 *C){
  1465. int _i=0;
  1466. C->_modulus=32;
  1467. C->_count=0;
  1468. C->_free=1;
  1469. C->_has_mem=0;
  1470. C->_item_mem=0;
  1471. {T55 *n=((T55*)new(55));
  1472. rT55make(n,0,((C)->_modulus)-(1));
  1473. C->_buckets=(T0 *)n;}
  1474. {T55 *n=((T55*)new(55));
  1475. rT55make(n,1,16);
  1476. C->_chain=(T0 *)n;}
  1477. {T265 *n=((T265*)new(265));
  1478. rT265make(n,1,16);
  1479. C->_store=(T0 *)n;}
  1480. {T41 *n=((T41*)new(41));
  1481. rT41make(n,1,16);
  1482. C->_keys=(T0 *)n;}
  1483. _i=1;
  1484. while (!((_i)==(rT55count((T55*)(C)->_chain)))) {
  1485. rT55put((T55*)(C)->_chain,(_i)+(1),_i);
  1486. _i=(_i)+(1);
  1487. }
  1488. rT55put((T55*)(C)->_chain,0,_i);
  1489. _i=0;
  1490. while (!((_i)>=((C)->_modulus))) {
  1491. rT55put((T55*)(C)->_buckets,0,_i);
  1492. _i=(_i)+(1);
  1493. }
  1494. }
  1495. void rT262forth(T262 *C){
  1496. int _i=0;
  1497. /*IF*/if ((rT55item((T55*)(C)->_chain,(C)->_item_mem_j))!=(0)) {
  1498. C->_item_mem_j=rT55item((T55*)(C)->_chain,(C)->_item_mem_j);
  1499. }
  1500. else {
  1501. _i=((C)->_item_mem_i)+(1);
  1502. while (!((rT55item((T55*)(C)->_buckets,_i))!=(0))) {
  1503. _i=(_i)+(1);
  1504. }
  1505. C->_item_mem_i=_i;
  1506. C->_item_mem_j=rT55item((T55*)(C)->_buckets,_i);
  1507. }
  1508. /*FI*/C->_item_mem=((C)->_item_mem)+(1);
  1509. }
  1510. void rT262first(T262 *C){
  1511. int _i=0;
  1512. _i=0;
  1513. while (!((rT55item((T55*)(C)->_buckets,_i))!=(0))) {
  1514. _i=(_i)+(1);
  1515. }
  1516. C->_item_mem_i=_i;
  1517. C->_item_mem_j=rT55item((T55*)(C)->_buckets,_i);
  1518. C->_item_mem=1;
  1519. }
  1520. void rT262resize(T262 *C,int a1){
  1521. int _p=0;
  1522. int _n=0;
  1523. int _i=0;
  1524. T0* _new_buc=NULL;
  1525. int _hash=0;
  1526. {T55 *n=((T55*)new(55));
  1527. rT55make(n,0,(a1)-(1));
  1528. _new_buc=(T0 *)n;}
  1529. _i=0;
  1530. while (!((_i)>=((C)->_modulus))) {
  1531. _n=rT55item((T55*)(C)->_buckets,_i);
  1532. while (!((_n)==(0))) {
  1533. _p=rT55item((T55*)(C)->_chain,_n);
  1534. _hash=(rT7hash_code((T7*)rT41item((T41*)(C)->_keys,_n)))%(a1);
  1535. rT55put((T55*)(C)->_chain,rT55item((T55*)_new_buc,_hash),_n);
  1536. rT55put((T55*)_new_buc,_n,_hash);
  1537. _n=_p;
  1538. }
  1539. _i=(_i)+(1);
  1540. }
  1541. C->_buckets=_new_buc;
  1542. C->_modulus=a1;
  1543. C->_item_mem=0;
  1544. }
  1545. T0 * rT262item(T262 *C,int a1){
  1546. T0 * R=NULL;
  1547. /*IF*/if (((C)->_item_mem)==(0)) {
  1548. rT262first(C);
  1549. while (!((a1)==((C)->_item_mem))) {
  1550. rT262forth(C);
  1551. }
  1552. R=rT263item((T263*)(C)->_store,(C)->_item_mem_j);
  1553. }
  1554.  else if (((C)->_item_mem)<=(a1)) {
  1555. while (!((a1)==((C)->_item_mem))) {
  1556. rT262forth(C);
  1557. }
  1558. R=rT263item((T263*)(C)->_store,(C)->_item_mem_j);
  1559. }
  1560. else {
  1561. C->_item_mem=0;
  1562. R=rT262item(C,a1);
  1563. }
  1564. /*FI*/return R;
  1565. }
  1566. T0* rT262clone(T262 *C,T0* a1){
  1567. T0* R=NULL;
  1568. /*IF*/if (((int)a1)) {
  1569. R=(T0 *)new(a1->id);
  1570. AF_1
  1571. XrT28copy(R,a1);
  1572. AF_0
  1573. }
  1574. /*FI*/return R;
  1575. }
  1576. T0 * rT262at(T262 *C,T0* a1){
  1577. T0 * R=NULL;
  1578. int _foo=0;
  1579. _foo=rT262has(C,a1);
  1580. R=rT263item((T263*)(C)->_store,(C)->_has_mem);
  1581. return R;
  1582. }
  1583. void rT262put(T262 *C,T0 * a1,T0* a2){
  1584. int _hash=0;
  1585. _hash=(rT7hash_code((T7*)a2))%((C)->_modulus);
  1586. /*IF*/if ((((C)->_has_mem)==(0))||(!(rT7is_equal((T7*)a2,rT41item((T41*)(C)->_keys,(C)->_has_mem))))) {
  1587. C->_has_mem=rT55item((T55*)(C)->_buckets,_hash);
  1588. while (!((((C)->_has_mem)==(0))||(rT7is_equal((T7*)a2,rT41item((T41*)(C)->_keys,(C)->_has_mem))))) {
  1589. C->_has_mem=rT55item((T55*)(C)->_chain,(C)->_has_mem);
  1590. }
  1591. /*IF*/if (((C)->_has_mem)==(0)) {
  1592. /*IF*/if (((C)->_count)>=(rT263count((T263*)(C)->_store))) {
  1593. rT262expand(C);
  1594. }
  1595. /*FI*/rT41put((T41*)(C)->_keys,a2,(C)->_free);
  1596. rT263put((T263*)(C)->_store,a1,(C)->_free);
  1597. C->_has_mem=(C)->_free;
  1598. C->_free=rT55item((T55*)(C)->_chain,(C)->_free);
  1599. rT55put((T55*)(C)->_chain,rT55item((T55*)(C)->_buckets,_hash),(C)->_has_mem);
  1600. rT55put((T55*)(C)->_buckets,(C)->_has_mem,_hash);
  1601. C->_count=((C)->_count)+(1);
  1602. /*IF*/if (((C)->_count)>(((C)->_modulus)*(2))) {
  1603. rT262resize(C,(2)*((C)->_modulus));
  1604. }
  1605. /*FI*/}
  1606. /*FI*/}
  1607. else {
  1608. rT263put((T263*)(C)->_store,a1,(C)->_has_mem);
  1609. }
  1610. /*FI*/C->_item_mem=0;
  1611. }
  1612. void rT262standard_copy(T262 *C,T0 * a1){
  1613. memcpy(C,a1,s[a1->id]);
  1614. }
  1615. void rT262copy(T262 *C,T0 * a1){
  1616. rT262standard_copy(C,a1);
  1617. C->_keys=rT262clone(C,((T262*)a1)->_keys);
  1618. C->_store=rT262clone(C,((T262*)a1)->_store);
  1619. C->_buckets=rT262clone(C,((T262*)a1)->_buckets);
  1620. C->_chain=rT262clone(C,((T262*)a1)->_chain);
  1621. }
  1622. void rT262expand(T262 *C){
  1623. int _old_size=0;
  1624. int _i=0;
  1625. C->_item_mem=0;
  1626. _old_size=rT263count((T263*)(C)->_store);
  1627. rT55resize((T55*)(C)->_chain,1,(2)*(_old_size));
  1628. rT41resize((T41*)(C)->_keys,1,(2)*(_old_size));
  1629. rT263resize((T263*)(C)->_store,1,(2)*(_old_size));
  1630. _i=(_old_size)+(1);
  1631. while (!((_i)==(rT55count((T55*)(C)->_chain)))) {
  1632. rT55put((T55*)(C)->_chain,(_i)+(1),_i);
  1633. _i=(_i)+(1);
  1634. }
  1635. rT55put((T55*)(C)->_chain,(C)->_free,_i);
  1636. C->_free=(_old_size)+(1);
  1637. }
  1638. int rT262has(T262 *C,T0* a1){
  1639. int R=0;
  1640. /*IF*/if ((((C)->_has_mem)==(0))||(!(rT7is_equal((T7*)a1,rT41item((T41*)(C)->_keys,(C)->_has_mem))))) {
  1641. C->_has_mem=rT55item((T55*)(C)->_buckets,(rT7hash_code((T7*)a1))%((C)->_modulus));
  1642. while (!((((C)->_has_mem)==(0))||(rT7is_equal((T7*)a1,rT41item((T41*)(C)->_keys,(C)->_has_mem))))) {
  1643. C->_has_mem=rT55item((T55*)(C)->_chain,(C)->_has_mem);
  1644. }
  1645. }
  1646. /*FI*/R=((C)->_has_mem)!=(0);
  1647. return R;
  1648. }
  1649. void rT262make(T262 *C){
  1650. int _i=0;
  1651. C->_modulus=32;
  1652. C->_count=0;
  1653. C->_free=1;
  1654. C->_has_mem=0;
  1655. C->_item_mem=0;
  1656. {T55 *n=((T55*)new(55));
  1657. rT55make(n,0,((C)->_modulus)-(1));
  1658. C->_buckets=(T0 *)n;}
  1659. {T55 *n=((T55*)new(55));
  1660. rT55make(n,1,16);
  1661. C->_chain=(T0 *)n;}
  1662. {T263 *n=((T263*)new(263));
  1663. rT263make(n,1,16);
  1664. C->_store=(T0 *)n;}
  1665. {T41 *n=((T41*)new(41));
  1666. rT41make(n,1,16);
  1667. C->_keys=(T0 *)n;}
  1668. _i=1;
  1669. while (!((_i)==(rT55count((T55*)(C)->_chain)))) {
  1670. rT55put((T55*)(C)->_chain,(_i)+(1),_i);
  1671. _i=(_i)+(1);
  1672. }
  1673. rT55put((T55*)(C)->_chain,0,_i);
  1674. _i=0;
  1675. while (!((_i)>=((C)->_modulus))) {
  1676. rT55put((T55*)(C)->_buckets,0,_i);
  1677. _i=(_i)+(1);
  1678. }
  1679. }
  1680. void rT61resize(T61 *C,int a1){
  1681. int _p=0;
  1682. int _n=0;
  1683. int _i=0;
  1684. T0* _new_buc=NULL;
  1685. int _hash=0;
  1686. {T55 *n=((T55*)new(55));
  1687. rT55make(n,0,(a1)-(1));
  1688. _new_buc=(T0 *)n;}
  1689. _i=0;
  1690. while (!((_i)>=((C)->_modulus))) {
  1691. _n=rT55item((T55*)(C)->_buckets,_i);
  1692. while (!((_n)==(0))) {
  1693. _p=rT55item((T55*)(C)->_chain,_n);
  1694. _hash=(rT7hash_code((T7*)rT41item((T41*)(C)->_keys,_n)))%(a1);
  1695. rT55put((T55*)(C)->_chain,rT55item((T55*)_new_buc,_hash),_n);
  1696. rT55put((T55*)_new_buc,_n,_hash);
  1697. _n=_p;
  1698. }
  1699. _i=(_i)+(1);
  1700. }
  1701. C->_buckets=_new_buc;
  1702. C->_modulus=a1;
  1703. C->_item_mem=0;
  1704. }
  1705. T0* rT61clone(T61 *C,T0* a1){
  1706. T0* R=NULL;
  1707. /*IF*/if (((int)a1)) {
  1708. R=(T0 *)new(a1->id);
  1709. AF_1
  1710. XrT28copy(R,a1);
  1711. AF_0
  1712. }
  1713. /*FI*/return R;
  1714. }
  1715. T0 * rT61at(T61 *C,T0* a1){
  1716. T0 * R=NULL;
  1717. int _foo=0;
  1718. _foo=rT61has(C,a1);
  1719. R=XrT63item((C)->_store,(C)->_has_mem);
  1720. return R;
  1721. }
  1722. void rT61put(T61 *C,T0 * a1,T0* a2){
  1723. int _hash=0;
  1724. _hash=(rT7hash_code((T7*)a2))%((C)->_modulus);
  1725. /*IF*/if ((((C)->_has_mem)==(0))||(!(rT7is_equal((T7*)a2,rT41item((T41*)(C)->_keys,(C)->_has_mem))))) {
  1726. C->_has_mem=rT55item((T55*)(C)->_buckets,_hash);
  1727. while (!((((C)->_has_mem)==(0))||(rT7is_equal((T7*)a2,rT41item((T41*)(C)->_keys,(C)->_has_mem))))) {
  1728. C->_has_mem=rT55item((T55*)(C)->_chain,(C)->_has_mem);
  1729. }
  1730. /*IF*/if (((C)->_has_mem)==(0)) {
  1731. /*IF*/if (((C)->_count)>=(XrT63count((C)->_store))) {
  1732. rT61expand(C);
  1733. }
  1734. /*FI*/rT41put((T41*)(C)->_keys,a2,(C)->_free);
  1735. XrT63put((C)->_store,a1,(C)->_free);
  1736. C->_has_mem=(C)->_free;
  1737. C->_free=rT55item((T55*)(C)->_chain,(C)->_free);
  1738. rT55put((T55*)(C)->_chain,rT55item((T55*)(C)->_buckets,_hash),(C)->_has_mem);
  1739. rT55put((T55*)(C)->_buckets,(C)->_has_mem,_hash);
  1740. C->_count=((C)->_count)+(1);
  1741. /*IF*/if (((C)->_count)>(((C)->_modulus)*(2))) {
  1742. rT61resize(C,(2)*((C)->_modulus));
  1743. }
  1744. /*FI*/}
  1745. /*FI*/}
  1746. else {
  1747. XrT63put((C)->_store,a1,(C)->_has_mem);
  1748. }
  1749. /*FI*/C->_item_mem=0;
  1750. }
  1751. void rT61standard_copy(T61 *C,T0 * a1){
  1752. memcpy(C,a1,s[a1->id]);
  1753. }
  1754. void rT61copy(T61 *C,T0 * a1){
  1755. rT61standard_copy(C,a1);
  1756. C->_keys=rT61clone(C,((T61*)a1)->_keys);
  1757. C->_store=rT61clone(C,((T61*)a1)->_store);
  1758. C->_buckets=rT61clone(C,((T61*)a1)->_buckets);
  1759. C->_chain=rT61clone(C,((T61*)a1)->_chain);
  1760. }
  1761.